Bei der Aufarbeitung der "Probleme", die ich mit Battle of Eris hatte, habe ich mich nochmal mit dem Scrolling beschäftigt. Dies war bei mir ein großes Problem, da ich den Grobscroll so gemacht habe, daß ich einen sichtbaren und einen nicht sichtbaren Bildschirm hatte, im nicht sichtbaren dann den gesamten Bildschirminhalt - also 1kB - um eine Zeile nach oben bewegt habe und dann umgeschaltet habe. Das kostet natürlich Speicher aber vor allem Rechenzeit. Auch die Kollisionserkennung bei dem Schritt ist problematisch. Dieses Kernproblem muss man also natürlich ganz anders lösen und es gibt da ein paar gute Ansätze und Beschreibungen im Netz.
Gestern habe ich mit Janko darüber geschrieben - er hatte mir mal eine kleine Demo gesendet, wo er Graphics 9 scrollt mit Displaylistmanipulation - und hier gibt es mindestens 2 gute Lösungsansätze, die von der Theorie her klar und logisch sind.
Hier im Forum habe ich aber dazu keinen Post gefunden und daher würde ich hier an der Stelle auch quasi als Nachschlagsmöglichkeit mit euch zusammen einen möglichst effektiven, verständlichen Code für MADS/Eclipse/WUDSN entwickeln mit folgenden Vorgaben:
- Verticales Softscrolling mittels DL-Manipulation
- Antic 4 mit 20 Zeilen, die untersten 3 Zeilen Antic 2 ohne Scrolling für die Anzeige.
- Zeile 1 verschmindet, in Zeile 20 wird per Random ein oder mehrere Zeichen geprintet. Zeile 20 scrollt auch soft rein...
- Einfacher für jeden verständlicher Code
Falls dieses Thema doch schon entsprechend irgendwo im Forum steht, dann habe ich es übersehen....
Mag das Thema auch für die Profis hier langweilig erscheinen, wird es dem Neuling vielleicht aber eine gute Basis geben können.
LG
Peter
Nicht in Deutsch, aber schau mal da:
https://playermissile.com/scrolling_tutorial/index.html
Ich finde Robs Tutorials einfach nur gut.
die Seite kenne ich sehr gut und finde sie auch excellent... aber halt in englisch und der Code ist mit den ganze includes unübersichtlich für Anfänger...
vielleicht ist das Thema hier auch uninteressant, dann gerne entsprechendes Feedback!
Moin!
Wie man beim ATARI die Bildinhalte scrollt, wird wahrscheinlich den "Programmierern" bekannt sein.
Aber es geht ja drum, dass man auch Wissen austauscht und so andere oder vielleicht sogar bessere Ansätze/Routinen kennenlernt.
Auch hat man so ein (deutsches) Nachschlagewerk, damit der künftige Programmierer von morgen leichter einsteigen kann.
Ich persönlich fände es toll, wenn gute Ansätze vllt. auch den Weg auf die ABBUC-Seite schaffen, in einem Bereich "Programmierung".
Manchmal ist es doch ganz schön anstrengend etwas im Forum wiederzufinden 😳
Grüße
Janko
Meine Projekte findest Du hier...
... vielleicht in einer Art Bibliothek für Assembler und Basic. Hier liegen dann z.B. Subroutinen, auf die man gut und schnell zugreifen kann...
Hallo!
Der Normalfall ist ja, dass man eine Map, z.B. 80 x 40 Zeichen, im Speicher vorhält und dann per Displaylist(-manipulation) und den Registern VSCROL und HSCROL das Scrolling realisiert. Das ist relativ einfach auf dem ATARI und geht auch ohne (großen) Rechenaufwand.
Das Anliegen ist aber, dass man einen Shooter programmieren möchte, der eine sehr lange Map horizontal ODER vertikal hat.
Wenn man die Map komplett im RAM ablegt, bleibt einem nicht viel Speicher für das eigentliche Programm. Zumal die Map nach einer Runde auch ggf. resettet werden muss.
Gerade wenn man gerne das Spiel auf ein Modul bringen möchte, sollte man sich gut überlegen, wie man den Speicherplatz einteilt.
Die Idee ist es, nur einen kleinen RAM-Bereich für die Bildschirmdarstellung zu nutzen und die MAP (ggf. komprimiert) im Speicher vorzuhalten und nur die angeforderte Zeile in den Bildschirm zu kopieren.
Eine Möglichkeit beim vertikalen Scrollen wäre, die Zeile, die gerade aus dem Bildschirm herausgescrollt wurde, an der anderen Seite wieder durch Displaylistmanipultaion einzufügen, nur mit neuem Inhalt. Den Bildschirmspeicher selber kopiert man nicht um, da dies zu viel Zeit in Anspruch nehmen würde.
Diese Variante ist sehr RAM-sparend, aber der Umgang bei z.B. der Kollisionserkennung ist erschwert.
Eine andere Möglichkeit wäre, dass man zwei Bildschirme untereinander im RAM vorhält und nun den Bildschirmausschnitt vom einem Bereich in den anderen scrollt. Am Ende angekommen beginnt man wieder von vorne. Während des scrollens baut man im nicht sichtbaren Bereich den Inhalt auf.
Diese Methode würde auch beim horizontalen Scrollen funktionieren.
Das ist jetzt sehr theoretisch, aber wir sollten ersteinmal Ideen sammeln und dann die favorisierte Idee ggf. anhand von Bildern und Quelltext erarbeiten.
Grüße
Janko
Meine Projekte findest Du hier...
Dr. Irata schrieb:
die Seite kenne ich sehr gut und finde sie auch excellent... aber halt in englisch und der Code ist mit den ganze includes unübersichtlich für Anfänger...
vielleicht ist das Thema hier auch uninteressant, dann gerne entsprechendes Feedback!
Ich wollte es dir nicht ausreden, dachte aber dass der Aufbau und die Beispiele ein guter Start sein könnten.
Mach weiter, ich finde die Idee gut.
Hi,
ich hab vor nicht allzu langer Zeit mal ein bisschen horizontales Scrolling ausprobiert und obwohl ich dachte, daß ich es richtig gemacht hatte waren da Ruckler drin...
Also ich hab bestimmt nichts gegen "erleuchtet mich" 🙂
CU, Erhard
Jede Info, die zu Hause auf meinem Rechner liegt habe ich unterwegs nicht verfügbar. Jede Info, die im Netz liegt finde ich nicht wieder, wenn ich sie benötige.
... wie gesagt, diese Woche habe ich noch großen Zeitmangel, danach starte ich hier mit euch zusammen den Vertekalscroll...
Ich habe eh superwenig Zeit und drängele bestimmt nicht.
Jede Info, die zu Hause auf meinem Rechner liegt habe ich unterwegs nicht verfügbar. Jede Info, die im Netz liegt finde ich nicht wieder, wenn ich sie benötige.
In diesem Thread
https://abbuc.de/forum/viewtopic.php?f=7&t=2070&p=16789&hilit=assemblerecke#p16789
findet man Peter Finzels Assemblerecke.
In Teil fünf und sieben sollte das, was Ihr sucht, zu finden sein.
... danke für den Link!
Habe mir mal kurz Teil 5 angeschaut und ja, das sieht gut aus... die Beispiele von Peter Finzel sind einfach gut. Das können wir hier sehr gut als Grundlage nutzen und hier tiefer analysieren und dann für MADS umarbeiten denke ich...
Hi,
Dr. Irata schrieb:
für MADS umarbeiten
noch besser fände ich "plain Assember", also keine MADS-Vereinfachungen wie MVA.
Quelltext in MADS kann gerne zusätzlich, dann lernt man gleichzeitig MADS.
Was meint ihr?
CU, Erhard
Jede Info, die zu Hause auf meinem Rechner liegt habe ich unterwegs nicht verfügbar. Jede Info, die im Netz liegt finde ich nicht wieder, wenn ich sie benötige.
Moin,
bin ich auch dafür!
Grüße
Janko
Meine Projekte findest Du hier...
patjomki schrieb:
In diesem Thread
https://abbuc.de/forum/viewtopic.php?f=7&t=2070&p=16789&hilit=assemblerecke#p16789
findet man Peter Finzels Assemblerecke.
In Teil fünf und sieben sollte das, was Ihr sucht, zu finden sein.
Die Assemblercke zum Scrolling war mein Einstieg ins Scrolling und mit dem Wissen habe ich auch mein vertikales Scrolling für mein "Geisterhaus" umgesetzt. Ist definitiv eine gute Grundlage zu dem Thema.
Erhard schrieb:
noch besser fände ich "plain Assember", also keine MADS-Vereinfachungen wie MVA.
Quelltext in MADS kann gerne zusätzlich, dann lernt man gleichzeitig MADS.
Was meint ihr?
CU, Erhard
Also die Assemblereckenroutinen für's Scrolling habe ich 1:1 in MADS übernommen, da musste nix angepasst werden. Benutze den MADS ohnehin ohne die ganzen Zusatzfeatures, ja selbst Makros benutze ich nicht.
Von daher: Dafür
... nun ja, ich nutze bei MADS eigentlich auch nur MVA und MWA .... das finde ich ganz praktisch - meistens 😉
Könnte ja auch sein, daß es jemand nativ auf dem Atari machen will.
Ich würde die MADS Vereinfachung als Kommentar einfügen, so a la:
LDA #17 ; Erläuterung bla bla (MVA #17 18)
STA 18
...
CU, Erhard
Jede Info, die zu Hause auf meinem Rechner liegt habe ich unterwegs nicht verfügbar. Jede Info, die im Netz liegt finde ich nicht wieder, wenn ich sie benötige.
Hallöle,
anbei mein erster kleiner Code für ein einfaches vertikales Scrolling für Antic 4 mit Anzeigefeld unten!
Ich habe jetzt mich für die relativ einfache Variante entschieden mit Manipulation der BS-Startadresse in der Displaylist - hier arbeite ich dann mit 2 Bildschirmen und kann somit ein wirklich laufendes Bild erzeugen und in die unterste Zeile entsprechend Zufallszeichen reinprinten... später kann man hier dann Landschaft kontinuierlich einprinten.
Ich habe alles so gehalten, daß man es leicht lesen und verwenden kann.
Verbesserungen oder Optimierungen gerne...
Liebe Grüße
Peter
org $4000
RANDOM = $d20a
RTCLOK = $0012
SDLSTL = $0230
VSCROL = $d405
dlx = 240
dlx2 = 242
xrandom .by 00
zaehler .by 00
zaehlerbs .by 00
;----------------- BS Start bei 0/16 = 4096 -
;----------------- Antic 4 ------------
dlist .byte 112,112,112
dl1 .byte 68+32,248,18
:18 .byte 04+32
.byte 112
.byte 66,112,17
:4 .byte 02
.byte 65
.word dlist
;-------------- Start Hauptprogramm -----------------------------
.proc main
start
lda <dlist ; Adresse der Displaylist wird
sta sdlstl ; ins Register eingetragen
lda >dlist
sta sdlstl+1
lda #208 ; Bildschirmspeicher 1 untere Reihe
sta dlx
lda #18
sta dlx+1
lda #200 ; Bildschirmspeicher 2 untere Reihe
sta dlx2
lda #21
sta dlx2+1
loop1
inc zaehler ; Feinscrollzähler
lda zaehler
cmp #8 ; bei 8 wird der Grobscroll ausgeführt
bne loop2
jsr grobscrol
lda #0 ; anschließend Zähler auf Null
sta zaehler
loop2
lda zaehler ; Wert vom FeinscrollzählerZähler
sta vscrol ; ins Register speichern
jsr wartes ; einmal auf den Takt warten - ersetzt VBI
jmp loop1
.endp
.proc grobscrol
;------- zunächst wird jeweils die letzte Zeile BS1 und BS2
;------- gelöscht
ldy #40
loop3
lda #0
sta (dlx),y
sta (dlx2),y
iny
cpy #80
bne loop3
;----------------------------------------------------------
;------- hier passiert der eigentliche Grobscroll indem die
;------- Bildschirmstartadresse in der Displaylist um 40
;------- also eine Zeile erhöht wird
clc
lda dl1+1
adc #40
sta dl1+1
lda dl1+2
adc #0
sta dl1+2
;----------------------------------------------------------
;------- die letzten Zeilen BS1 und BS2 müssen auch
;------- weiterwandern... statt zu addieren würde ich
;------- aber mittels Tabellen machen!! Spart CPU-Zeit
clc
lda dlx
adc #40
sta dlx
lda dlx+1
adc #0
sta dlx+1
clc
lda dlx2
adc #40
sta dlx2
lda dlx2+1
adc #0
sta dlx2+1
;-----------------------------------------------------------
;------- hier jetzt noch eine kleine Random-Füll-Routine, die
;------- immer in die letzte Zeile ein Randomzeichen an eine
;------- Randomstelle in der Zeile printet....
;------- ... später muss hier die Landschaft Zeile für Zeil
;------- aus einer Tabelle reingeprintet werden...
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda random
sta (dlx),y
sta (dlx2),y
;-------- nach 19 Zeilen muss der Zeilenzähler auf Null
;-------- gesetzt werden, außerdem müssen die Werte für
;-------- dl1 dlx und dlx2 rückgesetzt werden
inc zaehlerbs
lda zaehlerbs
cmp #19
bne loop4
lda #0
sta zaehlerbs
lda #208
sta dlx
lda #18
sta dlx+1
lda #200
sta dlx2
lda #21
sta dlx2+1
lda #248
sta dl1+1
lda #18
sta dl1+2
loop4
rts
.endp
.proc wartes
lda RTCLOK+2
loop5
cmp RTCLOK+2
beq loop5
rts
.endp
run main
Hier meine Routine für feines Scrolling in Graphics 0 (alle Richtungen via Joystick) in ACTION!
; Programmname : ScrollDemo
; Filename : SCROLL.ACT
; von : Carsten Strotmann
; letzte Aenderung: 20.12.91
; Bemerkung :
;INCLUDE "D2:SYSTEM.ACT"
MODULE;
BYTE shscrol=$70, svscrol=$71,
hscrol=$D404,vscrol=$D405,
vcount=$D40B
CARD POINTER dlptr=$72, adr, dlstart
CARD sdlstl=$230, sdlstlsav
BYTE ARRAY displayList =
[$70$70$70
$72$00$00$72$00$00$72$00$00$72$00$00
$72$00$00$72$00$00$72$00$00$72$00$00
$72$00$00$72$00$00$72$00$00$72$00$00
$72$00$00$72$00$00$72$00$00$72$00$00
$72$00$00$72$00$00$72$00$00$72$00$00
$72$00$00$72$00$00$72$00$00$72$00$00
$52$00$00$41$00$00]
PROC SetDL ()
BYTE u
sdlstlsav=sdlstl
sdlstl=displaylist
dlstart=displaylist+4
adr=0
dlptr=dlstart
FOR u=0 TO 24
DO
dlptr^=adr
dlptr==+3
adr==+40
OD
shscrol=2
svscrol=4
RETURN
PROC ScrollUp ()
BYTE u
svscrol==&$F ; Groessere Werte ausblenden
svscrol==+1
; SYNCRONISATION MIT DEM VBI, VER-
; MEIDET FLACKERN!
DO
UNTIL vcount>120
OD
; Scrollregister zuruecksetzen und
; Bildschirmspeicher scrollen
IF svscrol>=8 THEN
svscrol=0
dlptr=displaylist+4
FOR u=0 TO 24
DO
dlptr^==+40
dlptr==+3
OD
FI
vscrol=svscrol
RETURN
PROC ScrollDwn ()
BYTE u
svscrol==&$F
svscrol==-1
DO
UNTIL vcount>120
OD
IF svscrol=$FF THEN
svscrol=7
dlptr=displaylist+4
FOR u=0 TO 24
DO
dlptr^==-40
dlptr==+3
OD
FI
vscrol=svscrol
RETURN
PROC ScrollLft ()
BYTE u
shscrol==&7
shscrol==-1
DO
UNTIL vcount>120
OD
IF shscrol<=0 THEN
shscrol=4
dlptr=displaylist+4
FOR u=0 TO 24
DO
dlptr^==+1
dlptr==+3
OD
FI
hscrol=shscrol
RETURN
PROC ScrollRght ()
BYTE u
shscrol==&7
shscrol==+1
DO
UNTIL vcount>120
OD
IF shscrol>=4 THEN
shscrol=0
dlptr=displaylist+4
FOR u=0 TO 24
DO
dlptr^==-1
dlptr==+3
OD
FI
hscrol=shscrol
RETURN
PROC Err (BYTE errnum)
Graphics (0)
DO
PrintB (errnum)
OD
RETURN
PROC Pause (BYTE times)
BYTE u
FOR u=0 TO times
DO
DO
UNTIL vcount<12
OD
OD
RETURN
PROC Main ()
BYTE sti
Error=Err
SetDL ()
DO
sti=Stick(0) ! $F
IF sti&2 THEN
ScrollDwn ()
FI
IF sti&1 THEN
ScrollUp ()
FI
IF sti&4 THEN
ScrollLft ()
FI
IF sti&8 THEN
ScrollRght ()
FI
Pause (1)
UNTIL Strig(0)=0
OD
Graphics (0)
RETURN
https://mastodon.social/@cstrotm https://abbuc.social
... von Janko kam gerade noch der Tip für die DL:
dlist .byte 112,112,112
dl1 .byte 68+32,248,18
:17 .byte 04+32
.byte 04
.byte 112
.byte 66,112,17
:4 .byte 02
.byte 65
.word dlist
... damit scrollt man die letzte Reihe schön sanft rein!! Danke!
Hi,
Dr. Irata schrieb:
von Janko kam gerade noch der Tip für die DL:
bei Assembler Quellcodes bitte in eine der ersten Zeilen den verwendeten Assembler reinschreiben.
Zumindest ich erkenne nicht an der Art des Codes mal eben den verwendeten Assembler...
Ansonsten auf jeden Fall Danke.
Jetzt brauch ich nur noch Zeit das auszuprobieren ..
CU, Erhard
Jede Info, die zu Hause auf meinem Rechner liegt habe ich unterwegs nicht verfügbar. Jede Info, die im Netz liegt finde ich nicht wieder, wenn ich sie benötige.
... gute Idee... ich nehme bekanntlich MADS
In den letzten Tagen habe ich noch an der Scrollroutine gearbeitet und sie etwas erweitert:
Man kann jetzt mit dem Joystick nach oben oder unten scrollen... dabei wird jeweils entweder oben oder unten per Zufall ein Zeichen geprintet.
Der Code funktioniert sehr stabil und absolut "ruckelfrei" - man muss schon ein wenig Aufwand treiben und sehr genau coden, um das so hinzubekommen.... bis ich den allerletzten Ruckler weg hatte, waren etliche kleine Stellschrauben nötig...
Der Gesamtaspekt ist dem von Peter Finzel gar nicht so unähnlich - scheinbar - allerdings viel komplexer. Peter Finzel läßt ja sein Scrolling nach oben und unten über einen ganz fest definierten Speicherbereich scrollen und wenn man zum jeweiligen Ende kommt, ist Feierabend!
Mein Code ist ohne Ende in beide Richtungen und kann sehr schön für einen Scroller genutzt werden. Man könnte nun sehr einfach statt der Zufallszeichen eine ganz definierte Landschaft printen. Das geht mit dem Code von Finzel nicht!
; MADS Crossassembler
org $4000
RANDOM = $d20a
RTCLOK = $0012
SDLSTL = $0230
VSCROL = $d405
STICK0 = $278
dlx = 240
dlx2 = 242
xrandom .by 00
zaehler .by 04
zaehlerbs .by 00
;----------------- BS1 Start bei 0/16 = 4096
; BS1 Ende bei = 4816
; BS2 Start bei = 4856
; BS2 Ende bei = 5576
; DL Start bei 248/16 = 4856
;----- Antic 4 normales Spielfeld a 40 ------
dlist .byte 112,112,112
dl1 .byte 68+32
dl .byte 248,18
:17 .byte 04+32
.byte 04
.byte 112
.byte 66,220,14
:3 .byte 02
.byte 65
.word dlist
;-------------- Start Hauptprogramm -----------------------------
.proc main
start
lda <dlist ; Adresse der Displaylist wird
sta sdlstl ; ins Register eingetragen
lda >dlist
sta sdlstl+1
lda #208
sta dlx2
lda #18
sta dlx2+1
lda #240
sta dlx
lda #21
sta dlx+1
lda #$66
sta 708 ;Farbe 1
lda #$7f
sta 709 ;Farbe 2
lda #$00
sta 710 ;Farbe 3
lda #$22
sta 711 ;Farbe 4
lda #$00
sta 712 ;Farbe 5 Hitergrund
loop
lda stick0
cmp #13
bne @+
inc zaehler
@ lda stick0
cmp #14
bne @+
dec zaehler
@ lda zaehler
cmp #8
bne @+
jsr scrolup
lda #0
sta zaehler
@ lda zaehler
cmp #255
bne @+
jsr scroldown
lda #7
sta zaehler
@ lda zaehler
sta vscrol
jsr wartes
jmp loop
.endp
.proc scroldown
ldy #0
@ lda #0
sta (dlx),y
sta (dlx2),y
iny
cpy #40
bne @-
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda #7
sta (dlx),y
sta (dlx2),y
sec
lda dl
sbc #40
sta dl
lda dl+1
sbc #0
sta dl+1
sec
lda dlx
sbc #40
sta dlx
lda dlx+1
sbc #0
sta dlx+1
sec
lda dlx2
sbc #40
sta dlx2
lda dlx2+1
sbc #0
sta dlx2+1
dec zaehlerbs
lda zaehlerbs
cmp #0
bne @+
jmp decr
@ lda zaehlerbs
cmp #255
bne @+
decr
lda #20
sta zaehlerbs
lda #208
sta dlx2
lda #18
sta dlx2+1
lda #240
sta dlx
lda #21
sta dlx+1
lda #248
sta dl
lda #18
sta dl+1
@
rts
.endp
.proc scrolup
ldy #40
@ lda #0
sta (dlx),y
sta (dlx2),y
iny
cpy #80
bne @-
clc
lda dl1+1
adc #40
sta dl1+1
bcc @+
inc dl1+2
@
clc
lda dlx
adc #40
sta dlx
bcc @+
inc dlx+1
@
clc
lda dlx2
adc #40
sta dlx2
bcc @+
inc dlx2+1
@
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda #7
sta (dlx),y
sta (dlx2),y
inc zaehlerbs
lda zaehlerbs
cmp #20
bne @+
lda #0
sta zaehlerbs
lda #208
sta dlx
lda #18
sta dlx+1
lda #240
sta dlx2
lda #21
sta dlx2+1
lda #248
sta dl
lda #18
sta dl+1
@
rts
.endp
.proc wartes
lda RTCLOK+2
loop5
cmp RTCLOK+2
beq loop5
rts
.endp
run main
Hallo in die Runde,
ich habe jetzt diese gesamte Routine noch um eine relativ einfache horizontal scrolling Möglichkeit ergänzt.
Man kann jetzt zusätzlich noch um jeweils 10 Schritte nach links und rechts feinscrollen - also um insgesamt 20 Zeichen.
Wenn man das horizontale Feinscrolling implementiert, wird die Zeilenbreite von 40 auf 48 erhöht, um das auszugleichen (ich wollte jetzt für dieses Beispiel nicht die ganzen Adressen ändern) habe ich die Bildschirmbreite von 40 auf 32 reduziert (schmales Anzeigefeld) und somit die plus 8 ausgeglichen, ohne alles ändern zu müssen.
Dies ist jetzt der letzte Beitrag hinsichtlich vertikales (und damit auch gleichzeitig horizontales) Feinscrolling.
LG
Peter
; MADS Crossassembler
org $4000
RANDOM = $d20a
RTCLOK = $0012
SDLSTL = $0230
SDMCTL = $022f
VSCROL = $d405
HSCROL = $d404
STICK0 = $278
dlx = 240
dlx2 = 242
xrandom .by 00
zaehlerv .by 04
zaehlerh .by 04
zaehlerbs .by 00
zaehlerhs .by 70
;----------------- BS1 Start bei 0/16 = 4096
; BS1 Ende bei = 4816
; BS2 Start bei = 4856
; BS2 Ende bei = 5576
; DL Start bei 248/16 = 4856
;----- Antic 4 schmales Spielfeld a 32 ------
dlist .byte 112,112,112
dl1 .byte 68+32+16
dl .byte 248,18
:17 .byte 04+32+16
.byte 04+16
.byte 112
.byte 66,220,14
:3 .byte 02
.byte 65
.word dlist
;-------------- Start Hauptprogramm -----------------------------
.proc main
start
lda <dlist ; Adresse der Displaylist wird
sta sdlstl ; ins Register eingetragen
lda >dlist
sta sdlstl+1
dec sdmctl ;schmales Anzeigefeld
lda #208
sta dlx2
lda #18
sta dlx2+1
lda #240
sta dlx
lda #21
sta dlx+1
lda #$66
sta 708 ;Farbe 1
lda #$7f
sta 709 ;Farbe 2
lda #$00
sta 710 ;Farbe 3
lda #$22
sta 711 ;Farbe 4
lda #$00
sta 712 ;Farbe 5 Hitergrund
loop
lda stick0
cmp#11
bne weiter1
lda zaehlerhs
cmp #1
bcc @+
dec zaehlerhs
dec zaehlerh
@
lda zaehlerh
cmp #255
bne weiter1
jsr scrolleft
lda #7
sta zaehlerh
weiter1
lda stick0
cmp #7
bne weiter2
lda zaehlerhs
cmp #140
bcs @+
inc zaehlerhs
inc zaehlerh
@
lda zaehlerh
cmp #8
bne weiter2
jsr scrolright
lda #0
sta zaehlerh
weiter2
lda stick0
cmp #13
bne @+
inc zaehlerv
@ lda stick0
cmp #14
bne @+
dec zaehlerv
@ lda zaehlerv
cmp #8
bne @+
jsr scrolup
lda #0
sta zaehlerv
@ lda zaehlerv
cmp #255
bne @+
jsr scroldown
lda #7
sta zaehlerv
@ lda zaehlerv
sta vscrol
lda zaehlerh
sta hscrol
jsr wartes
jmp loop
.endp
.proc scrolleft
inc dl
inc dl
rts
.endp
.proc scrolright
dec dl
dec dl
rts
.endp
.proc scroldown
ldy #0
@ lda #0
sta (dlx),y
sta (dlx2),y
iny
cpy #40
bne @-
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda #7
sta (dlx),y
sta (dlx2),y
sec
lda dl
sbc #40
sta dl
lda dl+1
sbc #0
sta dl+1
sec
lda dlx
sbc #40
sta dlx
lda dlx+1
sbc #0
sta dlx+1
sec
lda dlx2
sbc #40
sta dlx2
lda dlx2+1
sbc #0
sta dlx2+1
dec zaehlerbs
lda zaehlerbs
cmp #0
bne @+
jmp decr
@ lda zaehlerbs
cmp #255
bne @+
decr
lda #20
sta zaehlerbs
lda #208
sta dlx2
lda #18
sta dlx2+1
lda #240
sta dlx
lda #21
sta dlx+1
lda #248
sta dl
lda #18
sta dl+1
@
rts
.endp
.proc scrolup
ldy #48
@ lda #0
sta (dlx),y
sta (dlx2),y
iny
cpy #80
bne @-
clc
lda dl
adc #40
sta dl
bcc @+
inc dl+1
@
clc
lda dlx
adc #40
sta dlx
bcc @+
inc dlx+1
@
clc
lda dlx2
adc #40
sta dlx2
bcc @+
inc dlx2+1
@
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda #7
sta (dlx),y
sta (dlx2),y
inc zaehlerbs
lda zaehlerbs
cmp #20
bne @+
lda #0
sta zaehlerbs
lda #208
sta dlx
lda #18
sta dlx+1
lda #240
sta dlx2
lda #21
sta dlx2+1
lda #248
sta dl
lda #18
sta dl+1
@
rts
.endp
.proc wartes
lda RTCLOK+2
loop5
cmp RTCLOK+2
beq loop5
rts
.endp
run main
Ich hatte da beim kurzen Überfliegen den Eindruck, dass man einige kleine Optimierungen am Code vornehmen könnte. Ich hoffe, dass ich am Wochenende die Zeit finde, das genauer zu ergründen.
Ich mache in jedem Fall Meldung, wenn ich das gesichtet habe 😉
PP´s of STARSOFTBerlin____github|meine Webseite|Demozoo
; MADS Crossassembler
org $4000
RANDOM = $d20a
RTCLOK = $0012
SDLSTL = $0230
SDMCTL = $022f
VSCROL = $d405
HSCROL = $d404
STICK0 = $278
dlx = 240
dlx2 = 242
xrandom .by 00
zaehlerv .by 04
zaehlerh .by 04
zaehlerbs .by 00
zaehlerhs .by 70
;----------------- BS1 Start bei 0/16 = 4096
; BS1 Ende bei = 4816
; BS2 Start bei = 4856
; BS2 Ende bei = 5576
; DL Start bei 248/16 = 4856
;----- Antic 4 schmales Spielfeld a 32 ------
dlist .byte 112,112,112
dl1 .byte 68+32+16
dl .byte 248,18
:17 .byte 04+32+16
.byte 04+16
.byte 112
.byte 66,220,14
:3 .byte 02
.byte 65
.word dlist
;-------------- Start Hauptprogramm -----------------------------
.proc main
start
lda <dlist ; Adresse der Displaylist wird
sta sdlstl ; ins Register eingetragen
lda >dlist
sta sdlstl+1
dec sdmctl ;schmales Anzeigefeld
lda #208
sta dlx2
lda #18
sta dlx2+1
lda #240
sta dlx
lda #21
sta dlx+1
lda #$66
sta 708 ;Farbe 1
lda #$7f
sta 709 ;Farbe 2
lda #$00
sta 710 ;Farbe 3
lda #$22
sta 711 ;Farbe 4
lda #$00
sta 712 ;Farbe 5 Hintergrund
loop
lda stick0
cmp #11
bne weiter1
lda zaehlerhs
beq @+ ; 0 ist kleiner als 1
; cmp #1
; bcc @+ ; := Wenn kleiner als 1 springe weiter.
dec zaehlerhs
dec zaehlerh
@
lda zaehlerh
beq weiter1 ; := 0 oder "Plus" Flag gesetzt?
bpl weiter1
; cmp #255
; bne weiter1 ; := kleiner als 0, dann weiter
jsr scrolleft
lda #7
sta zaehlerh
weiter1
lda stick0
cmp #7
bne weiter2
lda zaehlerhs
cmp #140
bcs @+
inc zaehlerhs
inc zaehlerh
@
lda zaehlerh
cmp #8
bne weiter2
jsr scrolright
lda #0
sta zaehlerh
weiter2
lda stick0
cmp #13
bne @+
inc zaehlerv
@ lda stick0
cmp #14
bne @+
dec zaehlerv
@ lda zaehlerv
cmp #8
bne @+
jsr scrolup
lda #0
sta zaehlerv
@ lda zaehlerv
beq @+ ; Programm läuft auch ohne dieses beq, dann spart man 2 Bytes
bpl @+
; cmp #255
; bne @+ ; := nicht kleiner als 0, dann weiter
jsr scroldown
lda #7
sta zaehlerv
@ lda zaehlerv
sta vscrol
lda zaehlerh
sta hscrol
jsr wartes
jmp loop
.endp
.proc scrolleft
inc dl
inc dl
rts
.endp
.proc scrolright
dec dl
dec dl
rts
.endp
.proc scroldown
; ldy #0
ldy #39 ; Loop gedreht, spart 2 Byte und etwas Zeit
@ lda #0
sta (dlx),y
sta (dlx2),y
; iny
; cpy #40
; bne @-
dey
bpl @-
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda #7
sta (dlx),y
sta (dlx2),y
sec
lda dl
sbc #40
sta dl
lda dl+1
sbc #0
sta dl+1
sec
lda dlx
sbc #40
sta dlx
lda dlx+1
sbc #0
sta dlx+1
sec
lda dlx2
sbc #40
sta dlx2
lda dlx2+1
sbc #0
sta dlx2+1
dec zaehlerbs
lda zaehlerbs
; cmp #0 ; unnötig
bne @+
jmp decr
@ lda zaehlerbs
beq @+ ; Programm läuft auch ohne dieses beq, dann spart man 2 Bytes
bpl @+
; cmp #255
; bne @+ ; := nicht kleiner als 0, dann weiter
decr
lda #20
sta zaehlerbs
lda #208
sta dlx2
lda #18
sta dlx2+1
lda #240
sta dlx
lda #21
sta dlx+1
lda #248
sta dl
lda #18
sta dl+1
@
rts
.endp
.proc scrolup
ldy #48
@ lda #0
sta (dlx),y
sta (dlx2),y
iny
cpy #80
bne @-
clc
lda dl
adc #40
sta dl
bcc @+
inc dl+1
@
clc
lda dlx
adc #40
sta dlx
bcc @+
inc dlx+1
@
clc
lda dlx2
adc #40
sta dlx2
bcc @+
inc dlx2+1
@
lda random
lsr
clc
adc #16
lsr
lsr
tay
lda #7
sta (dlx),y
sta (dlx2),y
inc zaehlerbs
lda zaehlerbs
cmp #20
bne @+
lda #0
sta zaehlerbs
lda #208
sta dlx
lda #18
sta dlx+1
lda #240
sta dlx2
lda #21
sta dlx2+1
lda #248
sta dl
lda #18
sta dl+1
@
rts
.endp
.proc wartes
lda RTCLOK+2
loop5
cmp RTCLOK+2
beq loop5
rts
.endp
run main
So, hier meine kleinen Anpassungen. Das Programm ist dadurch, statt 495 Bytes "nur" noch 489 Bytes groß, kommentiert man noch die beiden BEQ @+ aus, sogar nur noch 485 Bytes. Einen Hauch schneller wird es sicherlich auch, was bei größeren Aktionen sicherlich auch nicht unwichtig ist.
Edit: Mir ist gerade noch aufgefallen, dass es Sprünge gibt, wenn man Rechts/Links gescrollt hatte und dann Hoch und Runter etwas weiter scrollt. Das liegt nicht an meinen Änderungen. Das muss man sich also nochmal genauer anschauen, wenn man beide Scrollrichtungen haben möchte.
PP´s of STARSOFTBerlin____github|meine Webseite|Demozoo
... ja, er springt weil ich relativ einfach beim scrollen nach rechts und links den Wert von dl hochsetze oder runtersetze. Da bekomme ich natürlich einen rechts bzw links - Versatz. Wenn ich dann zusätzlich hoch- und runterscrolle und nach 20 Zeilen den dl-Wert rücksetze, dann passt das natürlich mit dem Seitversatz nicht mehr. Das müsste man entsprechend mit einberechnen....
Wer Lust und Zeit hat, kann sich gerne daran verdingen...
